RED HAT ENTERPRISE LINUX

Editing Text Files

Mastering vim and nano for System Administration

CIS126RH | RHEL System Administration 1
Mesa Community College

Learning Objectives

Understand vim's modal editing

Navigate between Normal, Insert, and Command modes

Perform essential vim operations

Open, edit, save, and exit files efficiently

Use vim navigation and editing commands

Move, search, copy, paste, and delete text

Use nano for quick edits

Navigate nano as a simpler alternative editor

We have four learning objectives for this module. First, we'll understand vim's unique modal editing paradigm - the concept of different modes for different tasks that initially confuses new users but becomes powerful once mastered. Second, we'll learn the essential vim operations: opening files, making changes, saving your work, and exiting - including how to exit when things go wrong. Third, we'll build proficiency with vim's navigation and editing commands - moving around efficiently, searching for text, and manipulating content with copy, paste, and delete operations. Fourth, we'll cover nano as an alternative for situations where a simpler editor is appropriate. The bulk of our focus is on vim because it's the industry standard and exam expectation, but knowing nano gives you options.

Why Text Editors Matter

In Linux, configuration files are plain text. System administration means editing files in /etc, writing scripts, and modifying configurations - all through text editors.

vim / vi

Powerful, ubiquitous, available on every Unix system. Modal editing provides efficiency once learned. RHCSA exam standard.

nano

Simple, intuitive, shows shortcuts on screen. Good for beginners and quick edits. Less powerful than vim.

RHCSA Exam: The exam environment has vim available. Knowing vim is essential for completing exam tasks efficiently.

Understanding why text editors matter in Linux is crucial context. Unlike Windows where you might use graphical dialog boxes to configure services, Linux stores nearly all configuration in plain text files. The SSH server reads /etc/ssh/sshd_config. The system hostname is in /etc/hostname. Firewall rules, user accounts, mount points, scheduled tasks - all text files. This design philosophy gives you complete control and makes configurations version-controllable, scriptable, and auditable. It also means you need to be proficient with a text editor. vim (and its predecessor vi) is the standard. It's installed by default on virtually every Unix-like system, from Linux servers to macOS to AIX. When you SSH into an unknown system, vi is there. It's powerful, efficient once learned, and expected knowledge for any serious administrator. The RHCSA exam provides vim, and completing tasks efficiently requires vim proficiency. nano is a simpler alternative - more intuitive for beginners with on-screen shortcut hints. It's useful for quick edits when vim's power isn't needed. However, nano isn't always installed, and relying on it limits your effectiveness.

vim vs vi

vi (Original)

Created in 1976 by Bill Joy
POSIX standard editor
Basic modal editing
Available on ALL Unix systems
Minimal features

vim (Vi IMproved)

Created in 1991 by Bram Moolenaar
Superset of vi
Syntax highlighting, plugins
Multiple undo, visual mode
Default on most Linux distros

# On RHEL, vi is actually vim
ls -l /usr/bin/vi
lrwxrwxrwx. 1 root root 3 Nov  1 10:00 /usr/bin/vi -> vim

# Check vim version
vim --version | head -1
VIM - Vi IMproved 8.2

Let's clarify the relationship between vi and vim. vi is the original visual editor created by Bill Joy in 1976. It's a POSIX standard, meaning it's guaranteed to be available on any standards-compliant Unix system. vi introduced modal editing - the revolutionary concept of different modes for different tasks. vim, or "Vi IMproved," was created by Bram Moolenaar in 1991. It's backward-compatible with vi but adds many features: syntax highlighting for programming and configuration files, plugin support, multiple levels of undo (vi had only single undo), visual mode for selecting text, split windows, and much more. On RHEL and most modern Linux distributions, when you type 'vi', you're actually running vim. The vi command is typically a symbolic link to vim, or vim running in vi-compatibility mode. For our purposes, we'll use vim, but the core concepts apply to vi as well. If you find yourself on a minimal system with only true vi, the essential commands we cover will still work.

vim Modal Editing

Modal editing means vim has different modes for different tasks. Keys do different things depending on the current mode.

NORMAL INSERT COMMAND VISUAL

NORMAL ← vim starts here

i a o
↓
INSERT
Esc to return

:
↓
COMMAND
Esc or Enter

v V
↓
VISUAL
Esc to return

Modal editing is vim's defining characteristic and the source of both its power and initial confusion. Unlike editors where every key you press appears on screen, vim has different modes where keys do different things. Normal mode is the default - vim starts here. In Normal mode, keys are commands: h, j, k, l move the cursor; x deletes a character; dd deletes a line. You don't type text in Normal mode; you navigate and manipulate existing text. Insert mode is for typing text. Press i, a, o, or similar keys from Normal mode to enter Insert mode. Now keys you press are inserted into the document. Press Escape to return to Normal mode. Command mode is entered by pressing colon from Normal mode. Here you type commands like :w to save, :q to quit, or :s to search and replace. Press Enter to execute or Escape to cancel. Visual mode is for selecting text. Press v for character selection, V for line selection. Selected text can then be copied, deleted, or modified. The key insight: when something unexpected happens in vim, press Escape to return to Normal mode and regain control. Escape is your safe haven.

Starting and Exiting vim

# Open vim with a file
vim filename.txt

# Open vim without a file
vim

# Open at specific line number
vim +50 filename.txt        # Opens at line 50

# Open in read-only mode
vim -R filename.txt
view filename.txt           # Same as vim -R

Essential Exit Commands (from Normal mode, type :)

            :q Quit (fails if unsaved changes)

            :q! Quit without saving (force)

            :w Write (save) the file

            :wq Write and quit

            :x Write and quit (same as :wq)

            ZZ Write and quit (Normal mode shortcut)

Let's start with the basics: opening vim and, crucially, how to exit. The classic joke is that vim is easy to learn but impossible to exit. We'll make sure that's not you. To open vim, simply type vim followed by a filename. If the file exists, it opens for editing. If it doesn't exist, vim creates a new empty buffer and will create the file when you save. You can open vim without a filename to start with an empty buffer - useful when you want to type something and decide the filename later. The +number syntax opens directly at a specific line - handy when an error message tells you the problem is on line 50. For viewing files without risk of accidental changes, vim -R or the view command opens in read-only mode. Now, the critical knowledge: exiting vim. All exit commands start with colon to enter Command mode. :q quits, but only if you haven't made changes. :q! force-quits, discarding any changes - use when you've made mistakes. :w saves without quitting. :wq or :x saves and quits - your normal exit. The ZZ shortcut in Normal mode (no colon) also saves and quits. If vim ever seems stuck, press Escape, then type :q! and Enter to force exit.

Entering Insert Mode

Key	Action	Use When
i	Insert before cursor	Most common - insert at current position
I	Insert at beginning of line	Adding content to start of line
a	Append after cursor	Adding after current character
A	Append at end of line	Adding content to end of line
o	Open new line below	Inserting a new line after current
O	Open new line above	Inserting a new line before current

Remember: Press Esc to return to Normal mode when done typing.

There are multiple ways to enter Insert mode, each optimized for different situations. The key i is the most common - it enters Insert mode with the cursor at its current position. Text you type is inserted before the character the cursor was on. Uppercase I moves to the beginning of the line and enters Insert mode - efficient for adding content at the start. The key a appends after the cursor position - useful when you want to add after the current character rather than before. Uppercase A moves to the end of the line and enters Insert mode - perfect for adding to line endings. The key o opens a new line below the current line and enters Insert mode - great for adding new lines of content. Uppercase O does the same but above the current line. These variations might seem like overkill for beginners, but they're optimizations that make editing faster once internalized. You don't have to memorize all of them immediately - start with i for insert and o for new lines. Add others as you get comfortable. The critical habit: always press Escape when you're done inserting text. This returns you to Normal mode where you can navigate, save, or execute commands.

Navigation in Normal Mode

Basic Movement

h j k l← ↓ ↑ →

0Beginning of line

$End of line

^First non-blank char

wNext word

bPrevious word

Jumping

ggGo to first line

GGo to last line

:nGo to line n

Ctrl+fPage forward

Ctrl+bPage backward

%Matching bracket

Arrow Keys: Arrow keys also work for navigation, but h/j/k/l keep your hands on the home row for faster editing.

Efficient navigation in Normal mode is key to productive vim use. The classic vim movement keys are h, j, k, l - left, down, up, right. They're on the home row of the keyboard, so your fingers never leave typing position. Arrow keys also work, but vim purists prefer hjkl for speed. Line navigation: 0 goes to the absolute beginning of the line, $ goes to the end, and caret goes to the first non-blank character. These match regular expression anchors if you know regex. Word movement: w moves forward to the start of the next word, b moves backward to the start of the previous word. These are faster than character-by-character movement. File navigation: gg goes to the first line, G goes to the last line. To go to a specific line number, type the number followed by G, or use :n in command mode. For example, 50G or :50 goes to line 50. Page movement: Ctrl+f moves forward one page, Ctrl+b moves backward. Useful for scrolling through long files. The percent sign jumps between matching brackets - position on a parenthesis, bracket, or brace and press % to jump to its match. These movements become muscle memory with practice, making vim navigation extremely fast.

Basic Editing Commands

Command	Action
x	Delete character under cursor
X	Delete character before cursor (backspace)
dd	Delete (cut) entire line
D	Delete from cursor to end of line
dw	Delete word from cursor
yy	Yank (copy) entire line
yw	Yank (copy) word
p	Paste after cursor
P	Paste before cursor
u	Undo last change
Ctrl+r	Redo (undo the undo)

These editing commands operate in Normal mode - you're not typing text but executing commands. The x key deletes the character under the cursor, like a forward delete. Uppercase X deletes the character before the cursor, like backspace. For larger deletions, dd deletes the entire current line. This is one of the most common vim commands. D deletes from the cursor position to the end of the line. The combination dw deletes from the cursor to the start of the next word. Yank is vim terminology for copy. yy yanks the entire current line, yw yanks a word. Yanked text goes into a buffer. Paste with p after the cursor or P before. For lines yanked with yy, paste puts the line below or above the current line. Undo with u - vim supports multiple undo levels, so you can press u repeatedly to undo many changes. Redo with Ctrl+r undoes your undo. These commands can be combined with counts: 5dd deletes five lines, 3yy yanks three lines. This command-count pattern is fundamental to vim's efficiency.

Search and Replace

# Search forward (from